﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.ComponentModel;
using System.IO;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Diagnostics;

namespace Cataloger.Kontrolki
{
    public class ListViewCataloger:ListView,IListaDrzewo
    {
		#region Fields (20) 

        /// <summary>
        /// Przewidziany do przetwarzania obiektów
        /// </summary>
        private BackgroundWorker bg;
        List<ListViewItemCataloger> Cache = new List<ListViewItemCataloger>();
        const int delaySelection=50;
        ToolStripTextBox filtr;
        int firstItem=0;
        public static ImageHashtable il = new ImageHashtable();
        ListView.ColumnHeaderCollection kolumny ;
        List<ColumnHeader> kolumnyKatalogi = new List<ColumnHeader>();
        List<ColumnHeader> kolumnyNosniki = new List<ColumnHeader>();
        List<ColumnHeader> kolumnyObiektyArchiwalne = new List<ColumnHeader>();
        List<ColumnHeader> kolumnyObiektyDyskowe = new List<ColumnHeader>();
        List<ColumnHeader> kolumnyObiektyDyskoweWyszukiwanie = new List<ColumnHeader>();
        int LiczbaZaznaczonych = 0;
        ListViewItemCataloger lvt = null;
        List<IObiektCatalogera> obiektyPrzetwarzane = new List<IObiektCatalogera>();
        SorterListViewCataloger sortowanie;
        ListViewItemCataloger temp;
        Timer time = new Timer();
        Properties.Settings ustawienia = new Cataloger.Properties.Settings();
        List<IObiektCatalogera> wczytaneObiekty = new List<IObiektCatalogera>();

		#endregion Fields 

		#region Constructors (1) 

        public ListViewCataloger()
        {
            time.Interval = delaySelection;
            time.Tick += new EventHandler(time_Tick);
            ustawienia.Reload();
            ObiektyPrzetwarzane = new List<IObiektCatalogera>();
            this.SmallImageList = il.ImageList;
            this.SmallImageList.ImageSize = new Size(24, 24);
            this.View = View.Details;

            this.LargeImageList = il.ImageList;
            this.LargeImageList.ImageSize = new Size(32, 32);

            sortowanie = new SorterListViewCataloger();
            this.HideSelection = false;
            
            this.FullRowSelect = true;
            this.DoubleBuffered = true;
            this.Dock = DockStyle.Fill;
            this.HideSelection = false;
            this.ShowItemToolTips = true;
            kolumny = new ColumnHeaderCollection(this);
            this.WyswietlKolumnyKatalogi();

            this.LargeImageList.Images.Add("folder", Properties.Resources.closeFolder);
            this.LargeImageList.Images.Add("katalog", Properties.Resources.katalog);
            this.LargeImageList.Images.Add("dyskTwardy", Properties.Resources.dyskTwardy);
            this.LargeImageList.Images.Add("dyskUSB", Properties.Resources.dyskUSB);
            this.LargeImageList.Images.Add("dyskSieciowy", Properties.Resources.dyskSieciowy);
            this.LargeImageList.Images.Add("dyskCDA", Properties.Resources.dyskCDA);
            this.LargeImageList.Images.Add("plytaCD", Properties.Resources.plytaCD);
            this.LargeImageList.Images.Add("dyskietka", Properties.Resources.dyskietka);
            this.LargeImageList.Images.Add("dyskSystemowy", Properties.Resources.dyskSystemowy);
            this.LargeImageList.Images.Add("dyskNieznany", Properties.Resources.dyskNieznany);
            this.LargeImageList.Images.Add("?", Properties.Resources.QUESTION4);

            this.VirtualListSize = 0;
            this.VirtualMode = true;
            KofiguracjaBg();     
        }

		#endregion Constructors 

		#region Properties (10) 

        public BackgroundWorker Bg
        {
            get { return bg; }
            set { bg = value; }
        }

        public ToolStripTextBox Filtr
        {
            get { return filtr; }
            set { filtr = value; }
        }

        public ContextMenuStrip MenuArchiwa { get; set; }

        public ContextMenuStrip MenuObiektyDyskowe { get; set; }

        public ContextMenuStrip MenuPlik { get; set; }

        [Browsable(false)]
        public List<IObiektCatalogera> ObiektyPrzetwarzane
        {
            get
            {
                return obiektyPrzetwarzane;
            }
            set
            {
                obiektyPrzetwarzane = value;
            }
        }

        public ToolStripProgressBar PasekPostepu
        {
            get;
            set;
        }

        public TreeViewCataloger TreeViewPowiazane
        {
            get;
            set;
        }

        internal Properties.Settings Ustawienia
        {
            get { return ustawienia; }
            set { ustawienia = value; }
        }

        public TabControl Zakladki
        {
            get;
            set;
        }

		#endregion Properties 

		#region Methods (36) 

		// Public Methods (21) 

        public void CzyscItemsy()
        {
            obiektyPrzetwarzane.Clear();
            Cache=null;
            this.VirtualListSize = 0;
         }

        public void Filtruj(string filtr)
        {
            CzyscItemsy();
            obiektyPrzetwarzane.Clear();
            foreach (IObiektCatalogera item in wczytaneObiekty)
            {
                if (item is Folder || item.Nazwa.ToLower().Contains(filtr.ToLower())|| Regex.IsMatch(item.Nazwa.ToLower(),filtr.ToLower().ToRegex()))
                {
                    obiektyPrzetwarzane.Add(item);
                }
            }
            this.VirtualListSize = obiektyPrzetwarzane.Count;
            this.TreeViewPowiazane.ToolStripLab2.Text = string.Format("Wylistowane elementy: {0} ({1})", this.ObiektyPrzetwarzane.Count, this.rozmiarObiektowPrzerwarzanych().ToProperUnit());
        }

         public ListViewItemCataloger FindNode(TreeNode tn, ObiektDyskowy obiekt)
        {
            if (lvt != null) return lvt;        
            foreach (TreeNode trn in tn.Nodes)
            {
                if (trn.Tag == obiekt.Rodzic)
                {
                    this.TreeViewPowiazane.EndUpdate();
                    TreeViewPowiazane.SelectedNode = trn;
                    trn.EnsureVisible();
                    lvt= this.FindItemWithText(obiekt.Nazwa) as ListViewItemCataloger;
                    return lvt;
                }
                else
                {
                    if (trn.Nodes.Count==1&&trn.Nodes[0].Text == "*")
                    {
                        trn.Expand();
                        trn.Collapse();
                    }
                    FindNode(trn, obiekt);
                }
            }
            return lvt;
        }

        public void PrzydzielKategorie()
        {
            if (this.SelectedIndices.Count > 1)
            {
                try
                {
                    FrmWybKategorii fWKat = new FrmWybKategorii();
                    if (fWKat.ShowDialog() == DialogResult.OK)
                    {
                        List<ObiektDyskowy> Obiekty = new List<ObiektDyskowy>();
                        for (int i = 0; i < SelectedIndices.Count; i++)
                        {

                        }

                        foreach (ObiektDyskowy p in Obiekty)
                        {
                            try
                            {
                                p.Kategoria = fWKat.Kategor;
                            }
                            catch { }
                        }
                    }
                }
                catch { }
            }
            else if (this.SelectedIndices.Count == 1)
            {
                    try
                    {
                        if (obiektyPrzetwarzane[SelectedIndices[0]] is ObiektDyskowy)
                        {
                            try
                            {
                                ObiektDyskowy p = (ObiektDyskowy)obiektyPrzetwarzane[SelectedIndices[0]];
                                FrmWybKategorii fWKat = new FrmWybKategorii(p);
                                if (fWKat.ShowDialog() == DialogResult.OK)
                                {
                                    p.Kategoria=fWKat.Kategor;
                                }
                            }
                            catch { }
                        }
                    }
                    catch { }
            }
        }

        public void PrzydzielOpis()
        {
            if (this.SelectedIndices.Count > 1)
            {
                try
                {
                    Cataloger.Okna.Pomocnicze.FrmPodajOpisNosnika frmOp = new Cataloger.Okna.Pomocnicze.FrmPodajOpisNosnika();
                    if (frmOp.ShowDialog() == DialogResult.OK)
                    {
                        List<ObiektDyskowy> Obiekty = new List<ObiektDyskowy>();
                    }
                }
                catch { }
            }

            else if (this.SelectedIndices.Count == 1)
            {
                try
                {
                    if (this.ObiektyPrzetwarzane[SelectedIndices[0]] is ObiektDyskowy)
                    {
                        try
                        {
                            ObiektDyskowy p = (ObiektDyskowy)this.ObiektyPrzetwarzane[SelectedIndices[0]];
                            Cataloger.Okna.Pomocnicze.FrmPodajOpisNosnika frmOp = new Cataloger.Okna.Pomocnicze.FrmPodajOpisNosnika(p);
                            if (frmOp.ShowDialog() == DialogResult.OK)
                            {
                                p.Opis = frmOp.Opis;
                            }
                        }
                        catch { }
                    }
                }
                catch { }
            }    
        }

        public long RozmiarZaznaczonychObiektow()
        {
            long suma = 0;
            for (int i = 0; i < this.SelectedIndices.Count; i++)
            {                IObiektCatalogera obiekt = ObiektyPrzetwarzane[SelectedIndices[i]];
                suma += obiekt.Rozmiar;
            }
            return suma;
        }

        public void WyswietlKatalogi(Katalogi kats)
        {
            this.VirtualListSize = 0;
            Cache=null;
            obiektyPrzetwarzane.Clear();
            foreach (Katalog item in kats)
            {
                obiektyPrzetwarzane.Add(item);
                
            }
            wczytaneObiekty.Clear();
            foreach (Katalog item in kats)
            {
                wczytaneObiekty.Add(item);

            }
            this.VirtualListSize = obiektyPrzetwarzane.Count;
        }

        public void WyswietlKolumnyKatalogi()
        {
            this.kolumnyKatalogi = new List<ColumnHeader>();
            this.kolumny.Clear();

            this.kolumnyKatalogi.Add(new ColHeader("Nazwa", ustawienia.szerKatNazwa,"szerKatNazwa"));
            this.kolumnyKatalogi.Add(new ColHeader("Ścieżka", ustawienia.szerKatSciez, "szerKatSciez"));
            this.kolumnyKatalogi.Add(new ColHeader("Data akt", ustawienia.szerKatDatAkt, "szerKatDatAkt"));
            this.kolumnyKatalogi.Add(new ColHeader("Data utw", ustawienia.szerKatDatUtw, "szerKatDatUtw"));
            this.kolumnyKatalogi.Add(new ColHeader("Foldery", ustawienia.szerKatFoldery, "szerKatFoldery"));
            this.kolumnyKatalogi.Add(new ColHeader("Pliki", ustawienia.szerKatPliki, "szerKatPliki"));
            this.kolumnyKatalogi.Add(new ColHeader("Haslo", ustawienia.szerKatHaslo, "szerKatHaslo"));
            this.kolumnyKatalogi.Add(new ColHeader("Skompresowany", ustawienia.szerKatSkompr, "szerKatSkompr"));
            this.kolumnyKatalogi.Add(new ColHeader("Nosniki", ustawienia.szerKatNosniki, "szerKatNosniki"));
            this.kolumnyKatalogi.Add(new ColHeader("Rozmiar", ustawienia.szerKatRozmiar, "szerKatRozmiar"));

            this.kolumny.AddRange(kolumnyKatalogi.ToArray());
        }

        public void WyswietlKolumnyNosniki()
        {
            this.kolumnyNosniki = new List<ColumnHeader>();
            this.kolumny.Clear();

            this.kolumnyNosniki.Add(new ColHeader("Nazwa", ustawienia.szerNosNazwa, "szerNosNazwa"));
            this.kolumnyNosniki.Add(new ColHeader("Katalog", ustawienia.szerNosKatalog, "szerNosKatalog"));
            this.kolumnyNosniki.Add(new ColHeader("Podłączony", ustawienia.szerNosPodlaczony, "szerNosPodlaczony"));
            this.kolumnyNosniki.Add(new ColHeader("Aktualizacja", ustawienia.szerNosAkt, "szerNosAkt"));
            this.kolumnyNosniki.Add(new ColHeader("Dodano", ustawienia.szerNosDodano, "szerNosDodano"));
            this.kolumnyNosniki.Add(new ColHeader("DyskFizyczny", ustawienia.szerNosDyskFiz, "szerNosDyskFiz"));
            this.kolumnyNosniki.Add(new ColHeader("DriveFormat", ustawienia.szerNosDriveFormat, "szerNosDriveFormat"));
            this.kolumnyNosniki.Add(new ColHeader("NrSeryjny", ustawienia.szerNosNrSeryjny, "szerNosNrSeryjny"));
            this.kolumnyNosniki.Add(new ColHeader("RodzajDysku", ustawienia.szerNosRodzajDysku, "szerNosRodzajDysku"));
            this.kolumnyNosniki.Add(new ColHeader("Status", ustawienia.szerNosStatus, "szerNosStatus"));
            this.kolumnyNosniki.Add(new ColHeader("Wielkosc", ustawienia.szerNosWielkosc, "szerNosWielkosc"));
            this.kolumnyNosniki.Add(new ColHeader("Wolne miejsce", ustawienia.szerNosWolne, "szerNosWolne"));

            this.kolumny.AddRange(kolumnyNosniki.ToArray());

        }

        public void WyswietlKolumnyObiektyArchiwum()
        {
            this.kolumnyObiektyArchiwalne = new List<ColumnHeader>();
            this.kolumny.Clear();

            this.kolumnyObiektyArchiwalne.Add(new ColHeader("Nazwa", ustawienia.szerObNazwa, "szerObNazwa"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("Rozsz", ustawienia.szerObRozsz, "szerObRozsz"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("Typ", ustawienia.szerObTyp, "szerObTyp"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("Nośnik", ustawienia.szerObNosnik, "szerObNosnik"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("Katalog", ustawienia.szerObKatalog, "szerObKatalog"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("Rozmiar", ustawienia.szerObRozmiar, "szerObRozmiar"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("DataUtw", 0));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("CzasUtw", 0));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("DzienUtw",0));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("DataMod", ustawienia.szerArchDataMod, "szerArchDataMod"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("CzasMod", ustawienia.szerArchCzasMod, "szerArchCzasMod"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("DzienMod", ustawienia.szerArchDzienMod, "szerArchDzienMod"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("DataDost",0));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("CzasDost", 0));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("DzienDost", 0));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("Atrybuty", ustawienia.szerObAtrybuty, "szerObAtrybuty"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("Kategoria", ustawienia.szerObKategoria, "szerObKategoria"));
            this.kolumnyObiektyArchiwalne.Add(new ColHeader("Sciezka", ustawienia.szerObSciezka, "szerObSciezka"));

            this.kolumny.AddRange(kolumnyObiektyDyskowe.ToArray());
        }

        public void WyswietlKolumnyObiektyDyskowe()
        {
            this.kolumnyObiektyDyskowe = new List<ColumnHeader>();
            this.kolumny.Clear();

            this.kolumnyObiektyDyskowe.Add(new ColHeader("Nazwa", ustawienia.szerObNazwa, "szerObNazwa"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("Rozsz", ustawienia.szerObRozsz, "szerObRozsz"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("Typ", ustawienia.szerObTyp, "szerObTyp"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("Nośnik", ustawienia.szerObNosnik, "szerObNosnik"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("Katalog", ustawienia.szerObKatalog, "szerObKatalog"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("Rozmiar", ustawienia.szerObRozmiar, "szerObRozmiar"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("DataUtw", ustawienia.szerObDatUtw, "szerObDatUtw"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("CzasUtw", ustawienia.szerObCzasUtw, "szerObCzasUtw"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("DzienUtw", ustawienia.szerObDzienUtw, "szerObDzienUtw"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("DataMod", ustawienia.szerObDatMod, "szerObDatMod"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("CzasMod", ustawienia.szerObCzasMod, "szerObCzasMod"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("DzienMod", ustawienia.szerObDzienMod, "szerObDzienMod"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("DataDost", ustawienia.szerObDatDos, "szerObDatDos"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("CzasDost", ustawienia.szerObCzasDos, "szerObCzasDos"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("DzienDost", ustawienia.szerObDzienDos, "szerObDzienDos"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("Atrybuty", ustawienia.szerObAtrybuty, "szerObAtrybuty"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("Kategoria", ustawienia.szerObKategoria, "szerObKategoria"));
            this.kolumnyObiektyDyskowe.Add(new ColHeader("Sciezka", ustawienia.szerObSciezka, "szerObSciezka"));

            this.kolumny.AddRange(kolumnyObiektyDyskowe.ToArray());
        }

        public void WyswietlKolumnyWyszukiwanieDyskowe()
        {
            this.kolumnyObiektyDyskoweWyszukiwanie = new List<ColumnHeader>();
            this.kolumny.Clear();

            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("Nazwa", ustawienia.szerObNazwa, "szerObNazwa"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("Rozsz", ustawienia.szerObRozsz, "szerObRozsz"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("Typ", ustawienia.szerObTyp, "szerObTyp"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("Nośnik", ustawienia.szerWyszNos, "szerWyszNos"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("Katalog", ustawienia.szerWyszKat, "szerWyszKat"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("Rozmiar", ustawienia.szerObRozmiar, "szerObRozmiar"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("DataUtw", ustawienia.szerObDatUtw, "szerObDatUtw"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("CzasUtw", ustawienia.szerObCzasUtw, "szerObCzasUtw"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("DzienUtw", ustawienia.szerObDzienUtw, "szerObDzienUtw"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("DataMod", ustawienia.szerObDatMod, "szerObDatMod"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("CzasMod", ustawienia.szerObCzasMod, "szerObCzasMod"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("DzienMod", ustawienia.szerObDzienMod, "szerObDzienMod"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("DataDost", ustawienia.szerObDatDos, "szerObDatDos"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("CzasDost", ustawienia.szerObCzasDos, "szerObCzasDos"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("DzienDost", ustawienia.szerObDzienDos, "szerObDzienDos"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("Atrybuty", ustawienia.szerObAtrybuty, "szerObAtrybuty"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("Kategoria", ustawienia.szerObKategoria, "szerObKategoria"));
            this.kolumnyObiektyDyskoweWyszukiwanie.Add(new ColHeader("Sciezka", ustawienia.szerObSciezka, "szerObSciezka"));

            this.kolumny.AddRange(kolumnyObiektyDyskoweWyszukiwanie.ToArray());
        }

        public void WyswietlObiketyDyskowe(HashSet<ObiektDyskowy> lista)
        {
            obiektyPrzetwarzane.Clear();
            wczytaneObiekty.Clear();
            foreach (ObiektDyskowy item in lista)
            {
                obiektyPrzetwarzane.Add(item);
            }
            foreach (ObiektDyskowy item in lista)
            {
                wczytaneObiekty.Add(item);
            }
            Filtruj(Filtr.Text);   
        }

        public void WyswietlObiketyDyskowe(List<IObiektCatalogera> lista)
        {
            obiektyPrzetwarzane.Clear();
            wczytaneObiekty.Clear();
            foreach (ObiektDyskowy item in lista)
            {
                obiektyPrzetwarzane.Add(item);
            }
            foreach (ObiektDyskowy item in lista)
            {
                wczytaneObiekty.Add(item);
            }
            Filtruj(Filtr.Text);
        }

        public void WyswietlObiketyWyszukiwania(HashSet<ArchiwumEntry> lista)
        {
        }

        public void WyswietlZawartosArchiwum(PlikArchiwum pArch)
        {
            this.VirtualListSize = 0;
            obiektyPrzetwarzane.Clear();
            foreach (ArchiwumEntry item in pArch.Entries)
            {
                ObiektyPrzetwarzane.Add(item);
            }
            wczytaneObiekty.Clear();
            foreach (ArchiwumEntry item in pArch.Entries)
            {
                wczytaneObiekty.Add(item);
            }
            this.VirtualListSize = pArch.Entries.Count;
        }

        public void WyswietlZawartosKatalogu(Katalog kat)
        {
            this.VirtualListSize = 0;
            Cache = null;
            obiektyPrzetwarzane.Clear();
            foreach (Nosnik item in kat.Nosniki)
            {
                obiektyPrzetwarzane.Add(item);
            }
            wczytaneObiekty.Clear();
            foreach (Nosnik item in kat.Nosniki)
            {
                wczytaneObiekty.Add(item);
            }
            this.VirtualListSize = obiektyPrzetwarzane.Count;            
        }

        /// <summary>
        /// Przejście wyżej w strukturze plików
        /// </summary>
        public void Wyzej()
        {
            if (this.Zakladki.SelectedIndex == 0)
            {
                try
                {
                    TreeNode tn = TreeViewPowiazane.SelectedNode;
                    if (tn.Parent != null)
                    {
                        tn.Collapse(false);
                        TreeViewPowiazane.SelectedNode = tn.Parent;
                        tn.Parent.EnsureVisible();
                    }
                }
                catch { }
            }
        }

        public void WyzejzArchiwum()
        {
            if (this.Zakladki.SelectedIndex == 0)
            {
                TreeNode tn = TreeViewPowiazane.SelectedNode;
                TreeViewPowiazane.SelectedNode = null;
                TreeViewPowiazane.SelectedNode = tn;
                tn.Expand();
                tn.EnsureVisible();
            }
        }

        public void ZlokalizujWKatalogu(ObiektDyskowy ob)
        {            
            try
            {
                lvt = null;
                this.TreeViewPowiazane.BeginUpdate();
                this.TreeViewPowiazane.CollapseAll();
                TreeViewPowiazane.SelectedNode = null;
                TreeViewPowiazane.Nodes[0].Expand();
                TreeViewPowiazane.Nodes[0].Nodes[ob.KataloG.Nazwa].Expand();
                TreeViewPowiazane.Nodes[0].Nodes[ob.KataloG.Nazwa].Nodes[ob.Nosnik.Nazwa].Expand();
                ListViewItemCataloger obiekt=FindNode(TreeViewPowiazane.Nodes[0].Nodes[ob.KataloG.Nazwa].Nodes[ob.Nosnik.Nazwa], ob);
                this.Focus();
                obiekt.Focused = true;
                obiekt.Selected = true;
                this.EnsureVisible(obiekt.Index);
            }
            catch { }
        }

        public void ZmienWidok()
        {
            switch (this.View)
            {
                case View.Details:
                    this.View = View.LargeIcon;
                    break;
                case View.LargeIcon:
                    this.View = View.List;
                    break;
                case View.List:
                    this.View = View.SmallIcon;
                    break;
                case View.SmallIcon:
                    this.View = View.Details;
                    break;
                case View.Tile:
                    this.View = View.Details;
                    break;
                default:
                    break;
            }
        }
		// Protected Methods (9) 

        protected override void OnCacheVirtualItems(CacheVirtualItemsEventArgs e)
        {
            base.OnCacheVirtualItems(e);
            try
            {
                if (Cache != null && e.StartIndex >= firstItem && e.EndIndex <= firstItem + Cache.Count)
                {
                    return;
                }
                firstItem = e.StartIndex;
                int length = e.EndIndex - e.StartIndex + 1;
                Cache = new List<ListViewItemCataloger>(length);
                for (int i = e.StartIndex; i <= e.EndIndex; i++)
                {
                    Cache.Add(new ListViewItemCataloger(ObiektyPrzetwarzane[i]));
                }
            }                       
            catch { }            
        }

        protected override void OnColumnClick(ColumnClickEventArgs e)
        {
            base.OnColumnClick(e);
            if (this.ObiektyPrzetwarzane != null && this.ObiektyPrzetwarzane.Count > 1)
            {
                if (Columns[e.Column] == this.sortowanie.ColumnToSort)
                {
                    if (this.sortowanie.OrderOfSort == SortOrder.Ascending)
                    {
                        this.sortowanie.OrderOfSort = SortOrder.Descending;
                        this.SetSortIcon(e.Column, SortOrder.Descending);
                    }
                    else
                    {
                        this.sortowanie.OrderOfSort = SortOrder.Ascending;
                        this.SetSortIcon(e.Column, SortOrder.Ascending);
                    }
                }
                else
                {
                    this.sortowanie.ColumnToSort = Columns[e.Column] as ColHeader;
                    this.sortowanie.OrderOfSort = SortOrder.Ascending;
                    this.SetSortIcon(e.Column, SortOrder.Ascending);
                }
                obiektyPrzetwarzane.Sort(sortowanie);
                Cache = null;
                this.BeginUpdate();
                this.Refresh();
                this.EndUpdate();
            }

        }

        protected override void OnColumnWidthChanged(ColumnWidthChangedEventArgs e)
        {
            base.OnColumnWidthChanged(e);
            ColHeader temp = this.Columns[e.ColumnIndex] as ColHeader;
            ustawienia[temp.PropertyName] = temp.Width;
        }

        protected override void OnItemActivate(EventArgs e)
        {
            base.OnItemActivate(e);
            if (this.SelectedIndices.Count > 0)
            {
                if (ObiektyPrzetwarzane[SelectedIndices[0]] is PlikArchiwum && this.Zakladki.SelectedIndex == 0)
                {
                    WyswietlKolumnyObiektyArchiwum();
                    PlikArchiwum pArch = ObiektyPrzetwarzane[SelectedIndices[0]] as PlikArchiwum;
                    WyswietlZawartosArchiwum(pArch);
                }
                else if (ObiektyPrzetwarzane[SelectedIndices[0]] is Plik)
                {
                    List<IUruchom> obiekty = new List<IUruchom>();
                    HashSet<string> AplikacjePotrzebne = new HashSet<string>();
                    for (int i = 0; i < this.SelectedIndices.Count; i++)
                    {
                        obiekty.Add(ObiektyPrzetwarzane[SelectedIndices[i]] as IUruchom);
                        AplikacjePotrzebne.Add(new FileAssociation().Get(Path.GetExtension((this.ObiektyPrzetwarzane[this.SelectedIndices[i]] as IUruchom).SciezkaRzeczyiwsta)));
                    }

                    foreach (string aplikacja in AplikacjePotrzebne)
                    {
                        Process pr = new Process();
                        pr.StartInfo.FileName = aplikacja;
                        foreach (IUruchom item in obiekty)
                        {
                            if (new FileAssociation().Get(Path.GetExtension(item.SciezkaRzeczyiwsta.ToLower())) == aplikacja)
                            {
                                pr.StartInfo.Arguments = "\"" + item.SciezkaRzeczyiwsta + "\"";
                                pr.Start();
                                pr.StartInfo.Arguments = string.Empty;
                            }
                        }
                    }

                }
                else if (ObiektyPrzetwarzane[SelectedIndices[0]] is IObiektCatalogera && this.Zakladki.SelectedIndex == 0)
                {
                    IObiektCatalogera obc = ObiektyPrzetwarzane[SelectedIndices[0]] as IObiektCatalogera;
                    TreeNode tn = this.TreeViewPowiazane.SelectedNode;
                    if (tn != null)
                    {
                        this.TreeViewPowiazane.SelectedNode = null;
                        tn.Expand();
                        this.TreeViewPowiazane.SelectedNode = tn.Nodes[obc.Nazwa];
                    }
                }
            }
        }

        protected override void OnKeyUp(KeyEventArgs e)
        {
            base.OnKeyUp(e);
            if (e.KeyData == Keys.Back)
            {
                try
                {
                    if (ObiektyPrzetwarzane[0] is ArchiwumEntry)
                    {
                        this.WyzejzArchiwum();
                    }
                    else { this.Wyzej(); }
                }
                catch { }
            }
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
            if (e.Button == MouseButtons.Right)
            {
                Point p = new Point(e.X, e.Y);
                ListViewItem item = this.GetItemAt(p.X, p.Y);
                if (item != null)
                {

                    try
                    {
                        if (!this.SelectedIndices.Contains(item.Index))
                        {
                            this.SelectedIndices.Clear();
                        }
                        item.Selected = true;

                    }
                    catch { }
                    if (this.SelectedIndices != null && this.SelectedIndices.Count > 1 && ObiektyPrzetwarzane[SelectedIndices[0]] is ObiektDyskowy)
                    {
                        this.MenuObiektyDyskowe.Show(this, p);

                    }
                    else if(this.SelectedIndices != null)
                    {
                        if (ObiektyPrzetwarzane[SelectedIndices[0]] is Katalog)
                        {
                            this.TreeViewPowiazane.MenuKatalog.Show(this, p);
                        }
                        else if (ObiektyPrzetwarzane[SelectedIndices[0]] is Nosnik)
                        {
                            this.TreeViewPowiazane.MenuNosnik.Show(this, p);
                        }
                        else if (ObiektyPrzetwarzane[SelectedIndices[0]] is Folder)
                        {
                            this.TreeViewPowiazane.MenuFolder.Show(this, p);
                        }
                        else if (ObiektyPrzetwarzane[SelectedIndices[0]] is Plik)
                        {
                            this.MenuPlik.Show(this, p);
                        }
                        else if (ObiektyPrzetwarzane[SelectedIndices[0]] is ArchiwumEntry)
                        {
                            this.MenuArchiwa.Show(this, p);
                        }
                    }
                }
            }
        }

        protected override void OnRetrieveVirtualItem(RetrieveVirtualItemEventArgs e)
        {
            base.OnRetrieveVirtualItem(e);
            try
            {
                if (Cache != null && e.ItemIndex >= firstItem && e.ItemIndex < firstItem + Cache.Count)
                {
                    e.Item = Cache[e.ItemIndex - firstItem];
                }
                else
                {
                    temp = new ListViewItemCataloger(ObiektyPrzetwarzane[e.ItemIndex]);
                    e.Item = temp;
                }
            }
            catch { }
        }

        protected override void OnSearchForVirtualItem(SearchForVirtualItemEventArgs e)
        {
            base.OnSearchForVirtualItem(e);
            for (int i = 0; i < ObiektyPrzetwarzane.Count; i++)
            {
                if (ObiektyPrzetwarzane[i].Nazwa == e.Text)
                {
                    e.Index = i;
                    return;
                }
            }
        }

        protected override void OnSelectedIndexChanged(EventArgs e)
        {
            base.OnSelectedIndexChanged(e);

            LiczbaZaznaczonych = SelectedIndices.Count;

            this.time.Start();           

        }
		// Private Methods (6) 

        void bg_DoWork(object sender, DoWorkEventArgs e)
        {

        }

        void bg_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
        }

        void bg_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {

        }

        private void KofiguracjaBg()
        {
            bg = new BackgroundWorker();
            bg.DoWork += new DoWorkEventHandler(bg_DoWork);
            bg.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bg_RunWorkerCompleted);
            bg.ProgressChanged += new ProgressChangedEventHandler(bg_ProgressChanged);
            bg.WorkerReportsProgress = true;
            bg.WorkerSupportsCancellation = true;
        }

        long rozmiarObiektowPrzerwarzanych()
        {
            long temp = 0;
            foreach (IObiektCatalogera item in ObiektyPrzetwarzane)
            {
                temp += item.Rozmiar;

            }
            return temp;
        }

        void time_Tick(object sender, EventArgs e)
        {
            if (LiczbaZaznaczonych == SelectedIndices.Count)
            {
                time.Stop();
                TreeViewPowiazane.CzyscInfo();
                if (SelectedIndices.Count > 0)
                {

                    try
                    {
                        if (ObiektyPrzetwarzane[SelectedIndices[SelectedIndices.Count - 1]] is IInfo)
                        {
                            IInfo info = ObiektyPrzetwarzane[SelectedIndices[SelectedIndices.Count - 1]] as IInfo;
                            TreeViewPowiazane.OpisObiektu(info as IInfo);
                        }


                        if (ObiektyPrzetwarzane[SelectedIndices[SelectedIndices.Count - 1]] is IUruchom)
                        {
                            IUruchom temp = ObiektyPrzetwarzane[SelectedIndices[SelectedIndices.Count - 1]] as IUruchom;
                            TreeViewPowiazane.InfoMoznaUruchomic(temp);

                        }
                        else if (ObiektyPrzetwarzane[SelectedIndices[SelectedIndices.Count - 1]] is Katalog)
                        {
                            Katalog temp = ObiektyPrzetwarzane[SelectedIndices[SelectedIndices.Count - 1]] as Katalog;

                            TreeViewPowiazane.DostepnoscKatalogu(temp);

                        }

                        this.TreeViewPowiazane.ToolStripLab2.Text = string.Format("Zaznaczone elementy: {0} ({1})",
                                                                        this.SelectedIndices.Count.ToString(),
                                                                        this.RozmiarZaznaczonychObiektow().ToProperUnit());


                    }
                    catch { }
                }
            }



        }

		#endregion Methods 

        #region IListaDrzewo Members

        public IObiektCatalogera ObiektZaznaczony
        {
            get 
            {
                return this.ObiektyPrzetwarzane[SelectedIndices[0]];
            }
        }

        #endregion
    }
}
